// 类的语法糖
var __extends = (this && this.__extends) || (function () {
    /** 设置原型（setPrototypeOf || {} 造一个 || function() {} ） */
    var extendStatics = function (newClass, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (newClass, b) { newClass.__proto__ = b; }) ||
            function (newClass, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) newClass[p] = b[p]; };
        return extendStatics(newClass, b);
    };
    /**
     * @param {function} newClass 派生类：立即执行函数
     * @param {function} extendsClass 继承类：立即执行函数
     */
    return function (newClass, extendsClass) {
        // 确定继承类的有效性
        if (typeof b !== "function" && extendsClass !== null)
            throw new TypeError("Class extends value " + String(extendsClass) + " is not a constructor or null");

        extendStatics(newClass, extendsClass);

        /** 新建一个函数，构造器（constructor）指向自己的构造函数 */
        function __() { this.constructor = newClass; }

        // 封装原型，赋值给 函数对象
        newClass.prototype = extendsClass === null ? 
            Object.create(extendsClass) // 原型设置为 null
            : (__.prototype = extendsClass.prototype, new __()); // 封装原型
    };
})();

var A = /** @class */ (function () {
    function A() {
        this.aaa = 231;
    }
    A.prototype.foo = function () {
        return this;
    };
    return A;
}());
var B = /** @class */ (function (_super) {
    __extends(B, _super);
    function B() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.bbb = 123;
        return _this;
    }
    // 成员方法
    B.prototype.bar = function () {
        return this;
    };
    return B;
}(A));
var b = new B();
console.log(b);
var x = b.bar().foo();
console.log(b);
